home *** CD-ROM | disk | FTP | other *** search
/ Champak 122 / Vol 122.iso / games / gem_stri.swf / scripts / __Packages / mx / utils / ObjectCopy.as < prev   
Encoding:
Text File  |  2011-01-06  |  30.8 KB  |  777 lines

  1. var ┬º\x01┬º = 164;
  2. loop0:
  3. while(true)
  4. {
  5.    if(eval("\x01") == 164)
  6.    {
  7.       set("\x01",eval("\x01") + 74);
  8.       ┬º┬ºpush(true);
  9.       continue;
  10.    }
  11.    if(eval("\x01") == 926)
  12.    {
  13.       set("\x01",eval("\x01") - 42);
  14.       if(┬º┬ºpop())
  15.       {
  16.          set("\x01",eval("\x01") - 798);
  17.       }
  18.       continue;
  19.    }
  20.    if(eval("\x01") == 709)
  21.    {
  22.       set("\x01",eval("\x01") + 136);
  23.       if(┬º┬ºpop())
  24.       {
  25.          set("\x01",eval("\x01") - 171);
  26.       }
  27.       continue;
  28.    }
  29.    if(eval("\x01") == 236)
  30.    {
  31.       set("\x01",eval("\x01") + 243);
  32.       prevFrame();
  33.       break;
  34.    }
  35.    if(eval("\x01") != 884)
  36.    {
  37.       if(eval("\x01") == 243)
  38.       {
  39.          set("\x01",eval("\x01") - 139);
  40.          break;
  41.       }
  42.       if(eval("\x01") != 238)
  43.       {
  44.          if(eval("\x01") == 845)
  45.          {
  46.             set("\x01",eval("\x01") - 171);
  47.             addr462:
  48.             var _loc2_ = ┬º┬ºpop();
  49.             _loc1_[┬º┬ºconstant(6)] = function(queue, event, handler)
  50.             {
  51.                if(queue != undefined)
  52.                {
  53.                   var _loc4_ = queue[┬º┬ºconstant(7)];
  54.                   var _loc1_ = undefined;
  55.                   _loc1_ = 0;
  56.                   while(_loc1_ < _loc4_)
  57.                   {
  58.                      var _loc2_ = queue[_loc1_];
  59.                      if(_loc2_ == handler)
  60.                      {
  61.                         queue[┬º┬ºconstant(8)](_loc1_,1);
  62.                         return undefined;
  63.                      }
  64.                      _loc1_ = _loc1_ + 1;
  65.                   }
  66.                }
  67.             };
  68.             _loc1_[┬º┬ºconstant(9)] = function(object)
  69.             {
  70.                if(eval(┬º┬ºconstant(1))[┬º┬ºconstant(3)][┬º┬ºconstant(4)][┬º┬ºconstant(10)] == undefined)
  71.                {
  72.                   eval(┬º┬ºconstant(1))[┬º┬ºconstant(3)][┬º┬ºconstant(4)][┬º┬ºconstant(10)] = new eval(┬º┬ºconstant(1))[┬º┬ºconstant(3)][┬º┬ºconstant(4)]();
  73.                }
  74.                object[┬º┬ºconstant(11)] = eval(┬º┬ºconstant(1))[┬º┬ºconstant(3)][┬º┬ºconstant(4)][┬º┬ºconstant(10)][┬º┬ºconstant(11)];
  75.                object[┬º┬ºconstant(12)] = eval(┬º┬ºconstant(1))[┬º┬ºconstant(3)][┬º┬ºconstant(4)][┬º┬ºconstant(10)][┬º┬ºconstant(12)];
  76.                object[┬º┬ºconstant(13)] = eval(┬º┬ºconstant(1))[┬º┬ºconstant(3)][┬º┬ºconstant(4)][┬º┬ºconstant(10)][┬º┬ºconstant(13)];
  77.                object[┬º┬ºconstant(14)] = eval(┬º┬ºconstant(1))[┬º┬ºconstant(3)][┬º┬ºconstant(4)][┬º┬ºconstant(10)][┬º┬ºconstant(14)];
  78.             };
  79.             _loc2_[┬º┬ºconstant(14)] = function(queueObj, eventObj)
  80.             {
  81.                var _loc7_ = ┬º┬ºconstant(15) + eventObj[┬º┬ºconstant(16)];
  82.                var _loc4_ = queueObj[_loc7_];
  83.                if(_loc4_ != undefined)
  84.                {
  85.                   var _loc5_ = undefined;
  86.                   for(_loc5_ in _loc4_)
  87.                   {
  88.                      var _loc1_ = _loc4_[_loc5_];
  89.                      var _loc3_ = typeof _loc1_;
  90.                      if(_loc3_ == ┬º┬ºconstant(17) || _loc3_ == ┬º┬ºconstant(18))
  91.                      {
  92.                         if(_loc1_[┬º┬ºconstant(19)] != undefined)
  93.                         {
  94.                            _loc1_[┬º┬ºconstant(19)](eventObj);
  95.                         }
  96.                         if(_loc1_[eventObj[┬º┬ºconstant(16)]] != undefined)
  97.                         {
  98.                            if(eval(┬º┬ºconstant(1))[┬º┬ºconstant(3)][┬º┬ºconstant(4)][┬º┬ºconstant(20)][eventObj[┬º┬ºconstant(16)]] == undefined)
  99.                            {
  100.                               _loc1_[eventObj[┬º┬ºconstant(16)]](eventObj);
  101.                            }
  102.                         }
  103.                      }
  104.                      else
  105.                      {
  106.                         _loc1_[┬º┬ºconstant(21)](queueObj,[eventObj]);
  107.                      }
  108.                   }
  109.                }
  110.             };
  111.             _loc2_[┬º┬ºconstant(13)] = function(eventObj)
  112.             {
  113.                if(eventObj[┬º┬ºconstant(22)] == undefined)
  114.                {
  115.                   eventObj[┬º┬ºconstant(22)] = this;
  116.                }
  117.                this[eventObj[┬º┬ºconstant(16)] + ┬º┬ºconstant(23)](eventObj);
  118.                this[┬º┬ºconstant(14)](this,eventObj);
  119.             };
  120.             _loc2_[┬º┬ºconstant(11)] = function(event, handler)
  121.             {
  122.                var _loc3_ = ┬º┬ºconstant(15) + event;
  123.                if(this[_loc3_] == undefined)
  124.                {
  125.                   this[_loc3_] = new ┬º\┬º\┬ºconstant(24)┬º();
  126.                }
  127.                _global[┬º┬ºconstant(25)](this,_loc3_,1);
  128.                eval(┬º┬ºconstant(1))[┬º┬ºconstant(3)][┬º┬ºconstant(4)][┬º┬ºconstant(6)](this[_loc3_],event,handler);
  129.                this[_loc3_][┬º┬ºconstant(26)](handler);
  130.             };
  131.             _loc2_[┬º┬ºconstant(12)] = function(event, handler)
  132.             {
  133.                var _loc2_ = ┬º┬ºconstant(15) + event;
  134.                eval(┬º┬ºconstant(1))[┬º┬ºconstant(3)][┬º┬ºconstant(4)][┬º┬ºconstant(6)](this[_loc2_],event,handler);
  135.             };
  136.             _loc1_[┬º┬ºconstant(10)] = undefined;
  137.             _loc1_[┬º┬ºconstant(20)] = {(┬º┬ºconstant(27)):1,(┬º┬ºconstant(28)):1,(┬º┬ºconstant(29)):1};
  138.             ┬º┬ºpush(┬º┬ºconstant(25)(eval(┬º┬ºconstant(1))[┬º┬ºconstant(3)][┬º┬ºconstant(4)][┬º┬ºconstant(5)],null,1));
  139.          }
  140.          else
  141.          {
  142.             if(eval("\x01") == 974)
  143.             {
  144.                set("\x01",eval("\x01") - 164);
  145.                if(┬º┬ºpop())
  146.                {
  147.                   set("\x01",eval("\x01") - 793);
  148.                }
  149.                continue;
  150.             }
  151.             if(eval("\x01") == 810)
  152.             {
  153.                set("\x01",eval("\x01") - 793);
  154.                eval(┬º┬ºpop())[┬º┬ºconstant(182)]();
  155.                return true;
  156.             }
  157.             if(eval("\x01") == 130)
  158.             {
  159.                set("\x01",eval("\x01") + 106);
  160.                if(┬º┬ºpop())
  161.                {
  162.                   set("\x01",eval("\x01") + 243);
  163.                }
  164.                continue;
  165.             }
  166.             if(eval("\x01") == 570)
  167.             {
  168.                set("\x01",eval("\x01") - 440);
  169.                ┬º┬ºpush(true);
  170.                continue;
  171.             }
  172.             if(eval("\x01") == 17)
  173.             {
  174.                set("\x01",eval("\x01") + 392);
  175.                ┬º┬ºpush(true);
  176.                continue;
  177.             }
  178.             if(eval("\x01") == 104)
  179.             {
  180.                set("\x01",eval("\x01") + 870);
  181.                ┬º┬ºpush(true);
  182.                continue;
  183.             }
  184.             if(eval("\x01") == 674)
  185.             {
  186.                set("\x01",eval("\x01") + 271);
  187.                ┬º┬ºpush(true);
  188.                continue;
  189.             }
  190.             if(eval("\x01") == 479)
  191.             {
  192.                set("\x01",eval("\x01") - 90);
  193.                if(!_global.mx)
  194.                {
  195.                   _global.mx = new Object();
  196.                }
  197.                ┬º┬ºpop();
  198.                if(!_global.mx.utils)
  199.                {
  200.                   _global.mx.utils = new Object();
  201.                }
  202.                ┬º┬ºpop();
  203.                if(!_global.mx.utils.ObjectCopy)
  204.                {
  205.                   var _loc1_ = null;
  206.                   mx.utils.ObjectCopy = _loc1_ = function()
  207.                   {
  208.                   };
  209.                   _loc2_ = _loc1_.prototype;
  210.                   _loc1_.copy = function(refObj)
  211.                   {
  212.                      var _loc1_ = new Function(refObj.__proto__.constructor)();
  213.                      mx.utils.ObjectCopy.copyProperties(_loc1_,refObj);
  214.                      return _loc1_;
  215.                   };
  216.                   _loc1_.copyProperties = function(dstObj, srcObj)
  217.                   {
  218.                      var _loc2_ = srcObj;
  219.                      var to;
  220.                      for(var i in _loc2_)
  221.                      {
  222.                         to = typeof _loc2_[i];
  223.                         if(to != "function")
  224.                         {
  225.                            if(to == "object")
  226.                            {
  227.                               if(_loc2_[i] instanceof Array)
  228.                               {
  229.                                  var p = new Array();
  230.                                  var _loc3_ = _loc2_[i];
  231.                                  var _loc1_ = 0;
  232.                                  while(_loc1_ < _loc3_.length)
  233.                                  {
  234.                                     p[_loc1_] = _loc3_[_loc1_];
  235.                                     _loc1_ = _loc1_ + 1;
  236.                                  }
  237.                                  dstObj[i] = p;
  238.                               }
  239.                               else if(_loc2_[i] instanceof String)
  240.                               {
  241.                                  dstObj[i] = new String(_loc2_[i]);
  242.                               }
  243.                               else if(_loc2_[i] instanceof Number)
  244.                               {
  245.                                  dstObj[i] = new Number(_loc2_[i]);
  246.                               }
  247.                               else if(_loc2_[i] instanceof Boolean)
  248.                               {
  249.                                  dstObj[i] = new Boolean(_loc2_[i]);
  250.                               }
  251.                               else
  252.                               {
  253.                                  dstObj[i] = mx.utils.ObjectCopy.copy(_loc2_[i]);
  254.                               }
  255.                            }
  256.                            else
  257.                            {
  258.                               dstObj[i] = _loc2_[i];
  259.                            }
  260.                         }
  261.                      }
  262.                   };
  263.                   ┬º┬ºpush(ASSetPropFlags(mx.utils.ObjectCopy.prototype,null,1));
  264.                }
  265.                ┬º┬ºpop();
  266.                break;
  267.             }
  268.             if(eval("\x01") == 86)
  269.             {
  270.                set("\x01",eval("\x01") + 623);
  271.                ┬º┬ºpush(true);
  272.                continue;
  273.             }
  274.             if(eval("\x01") == 706)
  275.             {
  276.                set("\x01",eval("\x01") - 215);
  277.                ┬º┬ºpop();
  278.                while(_loc2_ < eval(┬º┬ºconstant(70)))
  279.                {
  280.                   _loc1_ = prototype[┬º┬ºconstant(64)](_loc2_);
  281.                   if(_loc1_ != null && _loc1_ != 1 && ┬º┬ºconstant(72)(_loc1_,eval(┬º┬ºconstant(71))))
  282.                   {
  283.                      _loc3_[┬º┬ºconstant(38)](_loc1_);
  284.                   }
  285.                   _loc2_ = _loc2_ + 1;
  286.                }
  287.                var _loc0_ = _loc3_;
  288.                var _loc3_ = ┬º┬ºpop();
  289.                _loc2_ = ┬º┬ºpop();
  290.                _loc1_ = ┬º┬ºpop();
  291.                return _loc0_;
  292.             }
  293.             if(eval("\x01") == 253)
  294.             {
  295.                set("\x01",eval("\x01") + 673);
  296.                ┬º┬ºpush(true);
  297.                continue;
  298.             }
  299.             if(eval("\x01") == 945)
  300.             {
  301.                set("\x01",eval("\x01") - 702);
  302.                if(┬º┬ºpop())
  303.                {
  304.                   set("\x01",eval("\x01") - 139);
  305.                }
  306.                continue;
  307.             }
  308.             if(eval("\x01") == 409)
  309.             {
  310.                set("\x01",eval("\x01") + 158);
  311.                if(┬º┬ºpop())
  312.                {
  313.                   set("\x01",eval("\x01") + 3);
  314.                }
  315.                continue;
  316.             }
  317.             if(eval("\x01") != 364)
  318.             {
  319.                if(eval("\x01") == 567)
  320.                {
  321.                   set("\x01",eval("\x01") + 3);
  322.                   break;
  323.                }
  324.                if(eval("\x01") == 554)
  325.                {
  326.                   set("\x01",eval("\x01") - 190);
  327.                   if(┬º┬ºpop())
  328.                   {
  329.                      set("\x01",eval("\x01") - 111);
  330.                   }
  331.                }
  332.                else
  333.                {
  334.                   if(eval("\x01") != 491)
  335.                   {
  336.                      break;
  337.                   }
  338.                   set("\x01",eval("\x01") + 63);
  339.                   ┬º┬ºpush(true);
  340.                }
  341.                continue;
  342.             }
  343.             set("\x01",eval("\x01") - 111);
  344.             loop1:
  345.             while(true)
  346.             {
  347.                if(┬º┬ºpop() == 325)
  348.                {
  349.                   set("\x01",eval("\x01") + 555);
  350.                   if(┬º┬ºpop())
  351.                   {
  352.                      set("\x01",eval("\x01") - 177);
  353.                   }
  354.                }
  355.                else if(eval("\x01") == 780)
  356.                {
  357.                   set("\x01",eval("\x01") - 649);
  358.                   if(┬º┬ºpop())
  359.                   {
  360.                      set("\x01",eval("\x01") + 164);
  361.                   }
  362.                }
  363.                else
  364.                {
  365.                   if(eval("\x01") == 758)
  366.                   {
  367.                      set("\x01",eval("\x01") - 259);
  368.                      break loop0;
  369.                   }
  370.                   if(eval("\x01") == 499)
  371.                   {
  372.                      set("\x01",eval("\x01") + 281);
  373.                      ┬º┬ºpush(true);
  374.                   }
  375.                   else if(eval("\x01") == 763)
  376.                   {
  377.                      set("\x01",eval("\x01") - 236);
  378.                      ┬º┬ºpush(true);
  379.                   }
  380.                   else if(eval("\x01") == 194)
  381.                   {
  382.                      set("\x01",eval("\x01") + 564);
  383.                      if(┬º┬ºpop())
  384.                      {
  385.                         set("\x01",eval("\x01") - 259);
  386.                      }
  387.                   }
  388.                   else
  389.                   {
  390.                      if(eval("\x01") == 63)
  391.                      {
  392.                         set("\x01",eval("\x01") + 915);
  393.                         ┬º┬ºpop() extends ┬º┬ºpop() << (┬º┬ºpop() >>> ┬º┬ºpop());
  394.                         break loop0;
  395.                      }
  396.                      if(eval("\x01") == 43)
  397.                      {
  398.                         set("\x01",eval("\x01") + 720);
  399.                         break loop0;
  400.                      }
  401.                      if(eval("\x01") == 320)
  402.                      {
  403.                         set("\x01",eval("\x01") + 92);
  404.                         ┬º┬ºpush(true);
  405.                      }
  406.                      else if(eval("\x01") == 412)
  407.                      {
  408.                         set("\x01",eval("\x01") + 4);
  409.                         if(┬º┬ºpop())
  410.                         {
  411.                            set("\x01",eval("\x01") - 168);
  412.                         }
  413.                      }
  414.                      else
  415.                      {
  416.                         if(eval("\x01") == 880)
  417.                         {
  418.                            set("\x01",eval("\x01") - 177);
  419.                            ┬º┬ºpop() extends ┬º┬ºpop();
  420.                            ┬º┬ºpush(┬º┬ºpop() > ┬º┬ºpop());
  421.                            break loop0;
  422.                         }
  423.                         if(eval("\x01") == 978)
  424.                         {
  425.                            set("\x01",eval("\x01") - 653);
  426.                            ┬º┬ºpush(true);
  427.                         }
  428.                         else if(eval("\x01") == 956)
  429.                         {
  430.                            set("\x01",eval("\x01") - 636);
  431.                            loop3:
  432.                            while(true)
  433.                            {
  434.                               set(┬º┬ºpop(),eval("\x01") - 819);
  435.                               ┬º┬ºpush(true);
  436.                               while(true)
  437.                               {
  438.                                  if(eval("\x01") == 956)
  439.                                  {
  440.                                     set("\x01",eval("\x01") - 918);
  441.                                     ┬º┬ºpush(true);
  442.                                  }
  443.                                  else
  444.                                  {
  445.                                     if(eval("\x01") == 23)
  446.                                     {
  447.                                        set("\x01",eval("\x01") + 229);
  448.                                        prevFrame();
  449.                                        break loop0;
  450.                                     }
  451.                                     if(eval("\x01") == 195)
  452.                                     {
  453.                                        set("\x01",eval("\x01") + 159);
  454.                                        if(┬º┬ºpop())
  455.                                        {
  456.                                           set("\x01",eval("\x01") - 135);
  457.                                        }
  458.                                     }
  459.                                     else if(eval("\x01") == 38)
  460.                                     {
  461.                                        set("\x01",eval("\x01") + 307);
  462.                                        if(┬º┬ºpop())
  463.                                        {
  464.                                           set("\x01",eval("\x01") + 647);
  465.                                        }
  466.                                     }
  467.                                     else
  468.                                     {
  469.                                        if(eval("\x01") == 864)
  470.                                        {
  471.                                           set("\x01",eval("\x01") + 130);
  472.                                           break loop0;
  473.                                        }
  474.                                        if(eval("\x01") == 344)
  475.                                        {
  476.                                           set("\x01",eval("\x01") - 220);
  477.                                           ┬º┬ºpush(true);
  478.                                        }
  479.                                        else
  480.                                        {
  481.                                           if(eval("\x01") == 345)
  482.                                           {
  483.                                              set("\x01",eval("\x01") + 647);
  484.                                              break loop0;
  485.                                           }
  486.                                           if(eval("\x01") == 125)
  487.                                           {
  488.                                              break loop3;
  489.                                           }
  490.                                           if(eval("\x01") == 915)
  491.                                           {
  492.                                              set("\x01",eval("\x01") - 790);
  493.                                              if(┬º┬ºpop())
  494.                                              {
  495.                                                 set("\x01",eval("\x01") + 219);
  496.                                              }
  497.                                           }
  498.                                           else if(eval("\x01") == 124)
  499.                                           {
  500.                                              set("\x01",eval("\x01") + 740);
  501.                                              if(┬º┬ºpop())
  502.                                              {
  503.                                                 set("\x01",eval("\x01") + 130);
  504.                                              }
  505.                                           }
  506.                                           else if(eval("\x01") == 461)
  507.                                           {
  508.                                              set("\x01",eval("\x01") - 266);
  509.                                              ┬º┬ºpush(true);
  510.                                           }
  511.                                           else if(eval("\x01") == 252)
  512.                                           {
  513.                                              set("\x01",eval("\x01") + 663);
  514.                                              ┬º┬ºpush(true);
  515.                                           }
  516.                                           else
  517.                                           {
  518.                                              if(eval("\x01") == 354)
  519.                                              {
  520.                                                 set("\x01",eval("\x01") - 135);
  521.                                                 break loop0;
  522.                                              }
  523.                                              if(eval("\x01") == 173)
  524.                                              {
  525.                                                 set("\x01",eval("\x01") - 150);
  526.                                                 if(┬º┬ºpop())
  527.                                                 {
  528.                                                    set("\x01",eval("\x01") + 229);
  529.                                                 }
  530.                                              }
  531.                                              else
  532.                                              {
  533.                                                 if(eval("\x01") == 627)
  534.                                                 {
  535.                                                    set("\x01",eval("\x01") - 166);
  536.                                                    break loop0;
  537.                                                 }
  538.                                                 if(eval("\x01") == 992)
  539.                                                 {
  540.                                                    break;
  541.                                                 }
  542.                                                 if(eval("\x01") == 994)
  543.                                                 {
  544.                                                    set("\x01",eval("\x01") - 643);
  545.                                                    ┬º┬ºpush(true);
  546.                                                 }
  547.                                                 else
  548.                                                 {
  549.                                                    if(eval("\x01") != 351)
  550.                                                    {
  551.                                                       if(eval("\x01") == 219)
  552.                                                       {
  553.                                                          set("\x01",eval("\x01") + 123);
  554.                                                          stop();
  555.                                                       }
  556.                                                       break loop0;
  557.                                                    }
  558.                                                    set("\x01",eval("\x01") + 276);
  559.                                                    if(┬º┬ºpop())
  560.                                                    {
  561.                                                       set("\x01",eval("\x01") - 166);
  562.                                                    }
  563.                                                 }
  564.                                              }
  565.                                           }
  566.                                        }
  567.                                     }
  568.                                  }
  569.                               }
  570.                            }
  571.                            set("\x01",eval("\x01") + 219);
  572.                            while(true)
  573.                            {
  574.                               set(┬º┬ºpop(),eval(┬º┬ºpop()) - 45);
  575.                               if(┬º┬ºpop())
  576.                               {
  577.                                  set("\x01",eval("\x01") + 570);
  578.                               }
  579.                               while(eval("\x01") == 350)
  580.                               {
  581.                                  set("\x01",eval("\x01") + 97);
  582.                                  ┬º┬ºpush(true);
  583.                               }
  584.                               if(eval("\x01") == 402)
  585.                               {
  586.                                  set("\x01",eval("\x01") + 570);
  587.                                  prevFrame();
  588.                                  break loop0;
  589.                               }
  590.                               if(eval("\x01") != 447)
  591.                               {
  592.                                  if(eval("\x01") == 972)
  593.                                  {
  594.                                     set("\x01",eval("\x01") - 759);
  595.                                     stop();
  596.                                  }
  597.                                  break loop0;
  598.                               }
  599.                            }
  600.                         }
  601.                         else if(eval("\x01") == 952)
  602.                         {
  603.                            set("\x01",eval("\x01") - 774);
  604.                            if(┬º┬ºpop())
  605.                            {
  606.                               set("\x01",eval("\x01") + 324);
  607.                            }
  608.                         }
  609.                         else if(eval("\x01") == 703)
  610.                         {
  611.                            set("\x01",eval("\x01") - 594);
  612.                            ┬º┬ºpush(true);
  613.                         }
  614.                         else if(eval("\x01") == 18)
  615.                         {
  616.                            set("\x01",eval("\x01") + 934);
  617.                            ┬º┬ºpush(true);
  618.                         }
  619.                         else if(eval("\x01") == 109)
  620.                         {
  621.                            set("\x01",eval("\x01") - 66);
  622.                            if(┬º┬ºpop())
  623.                            {
  624.                               set("\x01",eval("\x01") + 720);
  625.                            }
  626.                         }
  627.                         else
  628.                         {
  629.                            if(eval("\x01") == 416)
  630.                            {
  631.                               set("\x01",eval("\x01") - 168);
  632.                               break loop0;
  633.                            }
  634.                            if(eval("\x01") == 131)
  635.                            {
  636.                               set("\x01",eval("\x01") + 164);
  637.                               break loop0;
  638.                            }
  639.                            if(eval("\x01") == 248)
  640.                            {
  641.                               set("\x01",eval("\x01") - 54);
  642.                               ┬º┬ºpush(true);
  643.                            }
  644.                            else if(eval("\x01") == 295)
  645.                            {
  646.                               set("\x01",eval("\x01") + 488);
  647.                               ┬º┬ºpush(true);
  648.                            }
  649.                            else
  650.                            {
  651.                               if(eval("\x01") == 178)
  652.                               {
  653.                                  set("\x01",eval("\x01") + 324);
  654.                                  prevFrame();
  655.                                  ┬º┬ºpush(┬º┬ºpop());
  656.                                  break loop0;
  657.                               }
  658.                               if(eval("\x01") == 783)
  659.                               {
  660.                                  set("\x01",eval("\x01") + 198);
  661.                                  if(┬º┬ºpop())
  662.                                  {
  663.                                     set("\x01",eval("\x01") - 963);
  664.                                  }
  665.                               }
  666.                               else
  667.                               {
  668.                                  if(eval("\x01") != 502)
  669.                                  {
  670.                                     break loop0;
  671.                                  }
  672.                                  set("\x01",eval("\x01") - 178);
  673.                                  if(!_global.mx)
  674.                                  {
  675.                                     _global.mx = new Object();
  676.                                  }
  677.                                  ┬º┬ºpop();
  678.                                  if(!_global.mx.events)
  679.                                  {
  680.                                     _global.mx.events = new Object();
  681.                                  }
  682.                                  ┬º┬ºpop();
  683.                                  if(!_global.mx.events.EventDispatcher)
  684.                                  {
  685.                                     mx.events.EventDispatcher = _loc1_ = function()
  686.                                     {
  687.                                     };
  688.                                     ┬º┬ºgoto(addr462);
  689.                                     ┬º┬ºpush(_loc1_.prototype);
  690.                                  }
  691.                               }
  692.                            }
  693.                         }
  694.                      }
  695.                   }
  696.                }
  697.                while(true)
  698.                {
  699.                   if(eval("\x01") == 271)
  700.                   {
  701.                      set("\x01",eval("\x01") - 261);
  702.                      ┬º┬ºpush(true);
  703.                      continue;
  704.                   }
  705.                   if(eval("\x01") == 981)
  706.                   {
  707.                      break;
  708.                   }
  709.                   if(eval("\x01") == 10)
  710.                   {
  711.                      set("\x01",eval("\x01") + 53);
  712.                      if(┬º┬ºpop())
  713.                      {
  714.                         set("\x01",eval("\x01") + 915);
  715.                      }
  716.                      continue;
  717.                   }
  718.                   if(eval("\x01") == 527)
  719.                   {
  720.                      set("\x01",eval("\x01") + 429);
  721.                      if(┬º┬ºpop())
  722.                      {
  723.                         set("\x01",eval("\x01") - 636);
  724.                      }
  725.                      continue;
  726.                   }
  727.                   continue loop1;
  728.                }
  729.                set("\x01",eval("\x01") - 963);
  730.                break loop0;
  731.             }
  732.          }
  733.          ┬º┬ºpop();
  734.          break;
  735.       }
  736.       set("\x01",eval("\x01") + 468);
  737.       if(┬º┬ºpop())
  738.       {
  739.          set("\x01",eval("\x01") - 215);
  740.       }
  741.       continue;
  742.    }
  743.    set("\x01",eval("\x01") - 798);
  744.    loop7:
  745.    while(true)
  746.    {
  747.       _loc2_[┬º┬ºconstant(152)][┬º┬ºconstant(153)](┬º┬ºpop() + ┬º┬ºpop());
  748.       _loc2_[┬º┬ºconstant(135)]()[┬º┬ºconstant(154)](_loc2_[┬º┬ºconstant(28)],_loc3_ + 1,eval(┬º┬ºconstant(148)) - _loc3_ + 1);
  749.       set(┬º┬ºconstant(146),eval(┬º┬ºconstant(148)));
  750.       _loc2_[┬º┬ºconstant(48)](┬º┬ºconstant(155),_loc3_,eval(┬º┬ºconstant(148)));
  751.       while(_loc1_ <= eval(┬º┬ºconstant(147)))
  752.       {
  753.          while(_loc1_ <= eval(┬º┬ºconstant(147)) && _loc2_[┬º┬ºconstant(43)][_loc1_] != null)
  754.          {
  755.             _loc1_ = _loc1_ + 1;
  756.          }
  757.          _loc3_ = _loc1_;
  758.          while(_loc1_ <= eval(┬º┬ºconstant(147)) && _loc2_[┬º┬ºconstant(43)][_loc1_] == null)
  759.          {
  760.             _loc2_[┬º┬ºconstant(35)] = _loc2_[┬º┬ºconstant(35)] + 1;
  761.             _loc2_[┬º┬ºconstant(43)][_loc1_] = 1;
  762.             _loc1_ = _loc1_ + 1;
  763.          }
  764.          set(┬º┬ºconstant(148),_loc1_ - 1);
  765.          if(_loc3_ <= eval(┬º┬ºconstant(148)))
  766.          {
  767.             continue loop7;
  768.          }
  769.       }
  770.       _loc0_ = eval(┬º┬ºconstant(146));
  771.       _loc3_ = ┬º┬ºpop();
  772.       _loc2_ = ┬º┬ºpop();
  773.       _loc1_ = ┬º┬ºpop();
  774.       return _loc0_;
  775.    }
  776. }
  777.